#include "/home/cgd/Log_system/log/log.hpp"
#include<vector>
#include<thread>
#include<chrono>



void bench(const std::string &logger_name, size_t thr_count, size_t msg_count, size_t msg_len)
{
    //1.获取日志器
    log::Logger::ptr logger = log::getLogger(logger_name);
    if(logger.get() == nullptr)
    {
        return ;
    }


    //2.创建指定长度的日志消息
    std::string msg(msg_len - 1, 'A'); //少一个字节，是为了给末尾到时候添加换行
    //3..创建指定数量的线程
    std::vector<std::thread> threads;
    std::vector<double> cost_arry(thr_count); 
    size_t msg_per_thr = msg_count/thr_count; //总日志数量/线程数量就是每个线程要输出的数量

    for(int i = 0; i < thr_count; i++)
    {
        threads.emplace_back([&, i]()
        {
            //4.线程函数内部开始计时
            auto start = std::chrono::high_resolution_clock::now();
            //5.开始循环写日志
            for(int j = 0; j < msg_per_thr; j++)
            {
                logger->fatal("%s", msg.c_str());
            }
            //6.线程函数内部结束计时
            auto end = std::chrono::high_resolution_clock::now(); //auto //默认以毫秒为单位
            std::chrono::duration<double> cost = end - start;
            cost_arry[i] = cost.count(); //计算出时间
            std::cout << "线程"<< i << ": " << "\t输出数量" << msg_per_thr << ", 耗时" << cost_arry[i] << "s" << std::endl;

        });

         
        for(int i = 0; i < thr_count; i++)
        {
            threads[i].join();
        }

         double max_cost = cost_arry[0];
           for(i = 0; i < cost_arry.size(); i++)
           {
                //7.计算总耗时：在多线程中，每个线程都会耗费时间，但是线程并发处理的，因此耗时最高的那个就是总时间
                max_cost = max_cost < cost_arry[i] ? cost_arry[i] : max_cost;
                size_t msg_per_sec = msg_count / max_cost; //每秒输出多少条消息
                size_t size_per_sec = (msg_count * msg_len) /max_cost/ 1024;
                //8. 进行输出打印
                std::cout<<"\t总耗时:"<< max_cost << "s\n";
                std::cout<<"\t每秒输出日志数量:" << msg_per_sec << "条\n";
                std::cout<<"\t每秒输出日志大小:" << size_per_sec << "KB\n";

           }
    }

}

void async_bench()
{
    
        std::unique_ptr<log::LoggerBuilder> builder(new log::GlobalLoggerBuilder());
        builder->buildLoggerName("async_logger");
        builder->buildFommater("%m%n");
        builder->buildLoggerType(log::LoggerType::LOGGER_ASYNC);
        builder->buildEnableUnSafeAsync(); //直接写入内存不需要等缓冲区交换
        builder->buildSink<log::FileSink>("./logfile/test.log");
        builder->build();
        bench("async_logger", 1, 1000000, 100);

}

void sync_bench()
{
    
        std::unique_ptr<log::LoggerBuilder> builder(new log::GlobalLoggerBuilder());
        builder->buildLoggerName("sync_logger");
        builder->buildFommater("%m%n");
        builder->buildLoggerType(log::LoggerType::LOGGER_SYNC);
        builder->buildSink<log::FileSink>("./logfile/test.log");
        builder->build();
        bench("sync_logger", 1, 1000000, 100);

}
int main()
{
    
     sync_bench();
     
}